>>= -package:basement -package:control-dsl

(>>=) :: forall a b . Monad m => m a -> (a -> m b) -> m b
base Prelude Control.Monad Control.Monad.Instances GHC.Base
Sequentially compose two actions, passing any value produced by the first as an argument to the second. 'as >>= bs' can be understood as the do expression 
do a <- as
bs a
(>>=) :: Monad m => m a -> (a -> Code m b) -> Code m b
template-haskell Language.Haskell.TH.CodeDo, ghc-lib Language.Haskell.TH.CodeDo
Module over monad operator for Code
(>>=) :: Monad m => m a -> (a -> m b) -> m b
hedgehog Hedgehog.Internal.Prelude, ghc GHC.Prelude.Basic, base-compat Control.Monad.Compat Prelude.Compat, protolude Protolude.Monad, haskell-gi-base Data.GI.Base.ShortPrelude, relude Relude.Monad.Reexport, rio RIO.Prelude, base-prelude BasePrelude BasePrelude.Operators, classy-prelude ClassyPrelude, numeric-prelude NumericPrelude NumericPrelude.Base, universum Universum.Monad.Reexport, base-compat-batteries Control.Monad.Compat, Cabal-syntax Distribution.Compat.Prelude, github GitHub.Internal.Prelude, numhask NumHask.Prelude, foundation Foundation, ghc-lib-parser GHC.Prelude.Basic, dimensional Numeric.Units.Dimensional.Prelude, rebase Rebase.Prelude, quaalude Essentials, hledger Hledger.Cli.Script, mixed-types-num Numeric.MixedTypes.PreludeHiding, xmonad-contrib XMonad.Config.Prime, stack Stack.Prelude, massiv-test Test.Massiv.Utils, incipit-base Incipit.Base, LambdaHack Game.LambdaHack.Core.Prelude Game.LambdaHack.Core.Prelude, cabal-install-solver Distribution.Solver.Compat.Prelude, can-i-haz Control.Monad.Except.CoHas Control.Monad.Reader.Has, loc Data.Loc.Internal.Prelude, yesod-paginator Yesod.Paginator.Prelude, distribution-opensuse OpenSuse.Prelude OpenSuse.Prelude, faktory Faktory.Prelude, hledger-web Hledger.Web.Import, termonad Termonad.Prelude, zio ZIO.Trans
Sequentially compose two actions, passing any value produced by the first as an argument to the second. 'as >>= bs' can be understood as the do expression 
do a <- as
bs a
(>>=) :: Bind m => m a -> (a -> m b) -> m b
semigroupoids Semigroupoids.Do
(>>=) :: Monad m => m a -> (a -> m b) -> m b
basic-prelude CorePrelude, prelude-compat Prelude2010
Sequentially compose two actions, passing any value produced by the first as an argument to the second.
type family (>>=) (arg_a17q6 :: m_a17kb a_a17kc) (arg_a17q7 :: (~>) a_a17kc (m_a17kb b_a17kd)) :: m_a17kb b_a17kd
singletons-base Control.Monad.Singletons Prelude.Singletons
(>>=) :: forall e s (a :: TYPE ra) (b :: TYPE rb) . Bind ra rb => Parser e s a -> (a -> Parser e s b) -> Parser e s b
bytesmith Data.Bytes.Parser.Rebindable
type family (>>=) (ma :: monad a) (f :: a ~> ((monad b) :: Type)) :: monad b
type-spec Test.TypeSpec.Internal.Apply
Bind to actions.
(>>=) :: Monad m => m a % 1 -> (a % 1 -> m b) % 1 -> m b
linear-base Control.Functor.Linear
x >>= g applies a linear function g linearly (i.e., using it exactly once) on the value of type a inside the value of type m a
(>>=) :: BindSyntax x y z => x a -> (a -> y b) -> z b
do-notation Language.Haskell.DoNotation
(>>=) :: (Dom m a, Dom m b, CBind m) => m a -> (a -> m b) -> m b
subcategories Control.Subcategory.RebindableSyntax
(>>=) :: Monad m => m a -> a -> m b -> m b
control-monad-free Control.Monad.Free
Sequentially compose two actions, passing any value produced by the first as an argument to the second.
data (>>=@#@$)
singletons-base Control.Monad.Singletons Prelude.Singletons
data (>>=@#@$$) (a6989586621679276649 :: m_a17kb a_a17kc)
singletons-base Control.Monad.Singletons Prelude.Singletons
type family (>>=@#@$$$) (a6989586621679276649 :: m_a17kb a_a17kc) (a6989586621679276650 :: (~>) a_a17kc (m_a17kb b_a17kd)) :: m_a17kb b_a17kd
singletons-base Control.Monad.Singletons Prelude.Singletons
(>>=/) :: Monad m => m a -> (a -> m b) -> m a
status-notifier-item StatusNotifier.Util
(>>==) :: Monad m => m b -> (a -> b -> m c) -> a -> m c
composition-extra Control.Monad.Syntax
(>>===) :: Monad m => m c -> (a -> b -> c -> m d) -> a -> b -> m d
composition-extra Control.Monad.Syntax
(>>====) :: Monad m => m d -> (a -> b -> c -> d -> m e) -> a -> b -> c -> m e
composition-extra Control.Monad.Syntax
(>>=====) :: Monad m => m e -> (a -> b -> c -> d -> e -> m f) -> a -> b -> c -> d -> m f
composition-extra Control.Monad.Syntax
(>>======) :: Monad m => m f -> (a -> b -> c -> d -> e -> f -> m g) -> a -> b -> c -> d -> e -> m g
composition-extra Control.Monad.Syntax
(>>=?) :: Fractional prob => T prob a -> (a -> Bool) -> T prob a
probability Numeric.Probability.Distribution
filter in infix form. Can be considered an additional monadic combinator, which can be used where you would want guard otherwise.
(:>>=) :: instr b -> (b -> ProgramT instr m a) -> ProgramViewT instr m a
operational Control.Monad.Operational
(%>>=) :: forall a_a17kc b_a17kd (t_a17ur :: m_a17kb a_a17kc) (t_a17us :: (~>) a_a17kc (m_a17kb b_a17kd)) . SMonad m_a17kb => Sing t_a17ur -> Sing t_a17us -> Sing (Apply (Apply (>>=@#@$) t_a17ur) t_a17us :: m_a17kb b_a17kd)
singletons-base Control.Monad.Singletons Prelude.Singletons
(>>>=) :: IxMonad m => m i j a -> (a -> m j k b) -> m i k b
indexed Control.Monad.Indexed